// let a = 0.1
// let b = 0.2
// console.log(a + b)

//冒泡排序: 前后元素两两对比,前者大于后者,就换位,反之不懂.第二个值继续与后面对比,依次类推,一轮对比下来,最大的值放到最后.然后进行第二轮的对比
//第二轮的对比,最后一个值就不需要比较了,因为他已经是最大的了,每一轮都会产生一个最大值,所以每一轮的对比数量都会相应的减去一个
let arr = [2, 5, 6, 3, 9, 3, 7, 8, 5]

function _bubble(arr) {
    for (let i = 0; i < arr.length - 1; i++) { //-1的目的,因为是两两对比,最后一次对比肯定是a>a+1,已经包含了最后一位元素,如果不-1,那么索引移动到最后一位,再+1就数组越界了
        for (let j = 0; j < arr.length - 1 - i; j++) {
            if (arr[j] > arr[j + 1]) {
                //如果前一个大于后一个,那么就交换位置,否则++向后移动索引
                swap(arr, j, j + 1)
            }
        }
    }
    return arr
}

function swap(arr, front, next) {
    let temp = arr[front]
    arr[front] = arr[next]
    arr[next] = temp
}

//选择排序: 设定一个最小值的索引,然后拿着这个索引去和数组中的数据一一对比,以此值为参照,将最小的值的索引赋值给min,一轮对比下来,能拿到数组中的
//最小值. 然后再将第二个值设置为最小值,去数组中一一对比,拿到最小值.然后和第二个值进行交换

Array.prototype.select = function () {
    for (let i = 0; i < this.length - 1; i++) { //-1的目的是,在第二个循环中会拿到次索引的下一个值,所以-1防止数组越界
        let min = i
        for (let j = i + 1; j < this.length; j++) {
            if (this[j] < this[min]) {
                min = j
            }
        }
        swap(this, min, i)
    }
    return this
}

function select2(arr) {
    for(let i = 0;i<arr.length-1;i++) {
        let min = i
        for(let j = i+1;j<arr.length;j++) {
            if(arr[min]>arr[j]) {
                min = j
            }
            
        }
        swap(arr,min,i)
    }
    return arr
}

//插入排序: 创建一个新数组,将原始数组的第一个值存入数组,然后遍历原始数组,取出第二个元素,此时也将新数组从后向前遍历,取出来的值,依次与
//旧数组中的值进行比较,如果,大于新数组中的值,就在新数组中当前值的后面添加一这个元素,否则继续比较. 直到新数组的元素都比较完,还没有匹配,就
//将此元素插到第一个索引处
Array.prototype._inster = function () {
    let handler = []
    handler.push(this[0]) //新建一个数组,并在数组中添加第原始数组的第一个值
    for (let i = 1; i < this.length; i++) { //原始数组从第一个索引处取值,与前一个值所在的数组进行比较,依次累加
        let old = this[i]
        for (let j = handler.length - 1; j >= 0; j--) { //从数组的尾部向前遍历
            if (handler[j] < old) { //如果原始数组中的值比新数组中的值大,那么就在此值的后面添加原始数组中的那个值,按照从小到大的排序
                handler.splice(j + 1, 0, old)
                break
            }
            if (j === 0) { //如果遍历到最后,old没有小于handler中所有的值,那么就放到数组的最前面,作为最小的值
                handler.unshift(old)
            }

        }

    }
    return handler
}

// console.log(arr._inster())

//快速排序: 将数组一分为二,有个中间值.判断比中间值小的放到左边.比中间值大的放到右边.然后递归,将每一个分割的数组都按照这种方式进行对比

function quick(arr) {
    if(arr.length<2) {
        return arr
    }
    const middleIndex = Math.floor(arr.length/2)
    const middleValue = arr.splice(middleIndex,1)
    const leftArr = []
    const rightArr = []
    for(let i = 0;i<arr.length;i++) {
        arr[i]<middleValue?leftArr.push(arr[i]):rightArr.push(arr[i])
    }
    return quick(leftArr).concat(middleValue,quick(rightArr))
}

function _inster2(arr) {

    let handler = []
    handler.push(arr[0])

    for(let i =1;i<arr.length;i++) {
        let old = arr[i]
        for(let j = handler.length-1;j>=0;j--) {
            if(handler[j]<old) {
                handler.splice(j+1,0,old)
                break
            }
            if(j === 0) {
                handler.unshift(old)
            }
        }
    }
    return handler
}



// let ary = [12, 8, 15, 16, 1, 24];
// console.log(_inster2(ary));


//数组和对象解构


let form = {
    name:'liang',
    age:12,
    num:01
}

let form2 = {
    file:'isFile'
}
// console.log(form)

let res ={...form,...form2}
console.log(res)



// let arra = [1,2,3,4,5,6]
// let res1 = {...arra}
// console.log(res1)